/**
 * 安全的日志迁移脚本
 * 专门用于合并代码后批量应用日志工具
 * 支持增量迁移，避免重复处理
 */

const fs = require('fs')
const path = require('path')
const glob = require('glob')

// 需要处理的文件类型
const FILE_PATTERNS = [
  'src/**/*.vue',
  'src/**/*.js',
  'src/**/*.ts'
]

// 需要替换的console方法映射
const CONSOLE_MAPPINGS = {
  'console.log': 'logger.log',
  'console.info': 'logger.info',
  'console.debug': 'logger.debug',
  'console.warn': 'logger.warn',
  'console.error': 'logger.error'
}

// 迁移状态文件
const MIGRATION_STATE_FILE = path.join(__dirname, '..', '.migration-state.json')

/**
 * 读取迁移状态
 */
function readMigrationState() {
  try {
    if (fs.existsSync(MIGRATION_STATE_FILE)) {
      return JSON.parse(fs.readFileSync(MIGRATION_STATE_FILE, 'utf8'))
    }
  } catch (error) {
    console.log('读取迁移状态失败，将重新开始')
  }
  return { processedFiles: [], lastRun: null }
}

/**
 * 保存迁移状态
 */
function saveMigrationState(state) {
  try {
    fs.writeFileSync(MIGRATION_STATE_FILE, JSON.stringify(state, null, 2), 'utf8')
  } catch (error) {
    console.error('保存迁移状态失败:', error.message)
  }
}

/**
 * 检查文件是否需要处理
 */
function needsProcessing(filePath, state) {
  // 检查是否已经处理过
  if (state.processedFiles.includes(filePath)) {
    return false
  }
  
  // 检查文件是否存在console语句
  try {
    const content = fs.readFileSync(filePath, 'utf8')
    return Object.keys(CONSOLE_MAPPINGS).some(method => content.includes(method))
  } catch (error) {
    return false
  }
}

/**
 * 处理单个文件
 */
function processFile(filePath, state) {
  console.log(`处理文件: ${filePath}`)
  
  let content = fs.readFileSync(filePath, 'utf8')
  let modified = false
  
  // 检查是否已经导入了logger
  const hasLoggerImport = content.includes("import logger from") || 
                         content.includes("import logger from '@/utils/logger'") ||
                         content.includes("import logger from './utils/logger'") ||
                         content.includes("import logger from '../utils/logger'")
  
  // 替换console语句
  for (const [consoleMethod, loggerMethod] of Object.entries(CONSOLE_MAPPINGS)) {
    const regex = new RegExp(consoleMethod.replace('.', '\\.'), 'g')
    if (content.includes(consoleMethod)) {
      content = content.replace(regex, loggerMethod)
      modified = true
      console.log(`  - 替换 ${consoleMethod} 为 ${loggerMethod}`)
    }
  }
  
  // 如果需要添加导入语句
  if (modified && !hasLoggerImport) {
    content = addImportStatement(content, filePath)
    console.log(`  - 添加logger导入语句`)
  }
  
  // 写回文件
  if (modified) {
    fs.writeFileSync(filePath, content, 'utf8')
    state.processedFiles.push(filePath)
    console.log(`  ✅ 文件已更新`)
  } else {
    console.log(`  ⏭️ 无需修改`)
  }
  
  return modified
}

/**
 * 添加导入语句
 */
function addImportStatement(content, filePath) {
  const lines = content.split('\n')
  let insertIndex = 0
  
  // 确定导入语句
  let importStatement
  if (filePath.includes('src/components/') || filePath.includes('src/views/')) {
    importStatement = "import logger from '@/utils/logger.js'"
  } else if (filePath.includes('src/utils/')) {
    importStatement = "import logger from './logger.js'"
  } else {
    importStatement = "import logger from '../utils/logger.js'"
  }
  
  // 找到合适的位置插入导入语句
  for (let i = 0; i < lines.length; i++) {
    if (lines[i].startsWith('import ') || lines[i].startsWith('const ') || lines[i].startsWith('let ')) {
      insertIndex = i + 1
    } else if (lines[i].trim() === '' && insertIndex > 0) {
      break
    }
  }
  
  lines.splice(insertIndex, 0, importStatement)
  return lines.join('\n')
}

/**
 * 生成迁移报告
 */
function generateReport(state, processedCount) {
  const report = {
    timestamp: new Date().toISOString(),
    processedFiles: processedCount,
    totalProcessed: state.processedFiles.length,
    consoleMappings: CONSOLE_MAPPINGS,
    summary: {
      newFilesProcessed: processedCount,
      totalFilesProcessed: state.processedFiles.length
    }
  }
  
  const reportPath = path.join(__dirname, '..', 'migration-report.json')
  fs.writeFileSync(reportPath, JSON.stringify(report, null, 2), 'utf8')
  console.log(`\n📊 迁移报告已生成: ${reportPath}`)
}

/**
 * 主函数
 */
function main() {
  console.log('🚀 开始安全迁移控制台日志...\n')
  
  // 读取迁移状态
  const state = readMigrationState()
  console.log(`📋 迁移状态: 已处理 ${state.processedFiles.length} 个文件`)
  
  // 获取所有需要处理的文件
  const allFiles = []
  FILE_PATTERNS.forEach(pattern => {
    const files = glob.sync(pattern, { cwd: path.join(__dirname, '..') })
    allFiles.push(...files.map(file => path.join(__dirname, '..', file)))
  })
  
  // 过滤需要处理的文件
  const filesToProcess = allFiles.filter(file => needsProcessing(file, state))
  
  console.log(`找到 ${filesToProcess.length} 个新文件需要处理\n`)
  
  if (filesToProcess.length === 0) {
    console.log('✅ 所有文件都已处理完成！')
    return
  }
  
  // 处理每个文件
  let processedCount = 0
  filesToProcess.forEach(file => {
    if (processFile(file, state)) {
      processedCount++
    }
  })
  
  // 保存迁移状态
  state.lastRun = new Date().toISOString()
  saveMigrationState(state)
  
  // 生成报告
  generateReport(state, processedCount)
  
  console.log('\n✅ 安全迁移完成!')
  console.log(`📈 本次处理了 ${processedCount} 个新文件`)
  console.log(`📊 累计处理了 ${state.processedFiles.length} 个文件`)
  console.log('\n📝 下一步:')
  console.log('1. 检查修改的文件是否正确')
  console.log('2. 运行 npm run serve 测试开发环境')
  console.log('3. 运行 npm run build 测试生产环境')
  console.log('4. 查看 migration-report.json 了解迁移详情')
}

// 运行脚本
if (require.main === module) {
  main()
}

module.exports = { processFile, addImportStatement, generateReport }
